package cn.demoncat.util.lang.entity;

import cn.demoncat.util.exception.*;
import cn.demoncat.util.lang.*;
import cn.demoncat.util.lang.constant.IntegerConstant;
import cn.demoncat.util.lang.constant.LongConstant;
import cn.demoncat.util.lang.constant.StatusConstant.Common;
import cn.demoncat.util.lang.constant.StringConstant;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.annotation.JSONField;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 描述：返回结果<br/>
 * 
 * 注：因为FastJSON序列化时读取get方法，所以非静态方法尽量不要用get，必要时使用@JSONField忽略
 * 
 *
 * @author 延晓磊
 *
 * @since 2016年4月10日
 */
public class Result {

	private static final Logger LOG = LoggerFactory.getLogger(Result.class);
 
	// 响应状态
	private String status;

	// 响应消息
	private String msg;

	// 响应的数据：Map/JSONObject/Object
	private Object data;

	/**
	 * REST调用错误日志
	 */
	private static final String REST_ERROR_LOG = "REST调用错误：result = {}";
	
	/**
	 * Jsonp括号
	 */
	private static final String JSONP_LEFT = "(";
	private static final String JSONP_RIGHT = ")";
	
	/**
	 * 描述：返回结果枚举
	 * <p>
	 * 成功：200，Info
	 * 错误：400，Warn
	 * 异常：500，Error
	 * 节点：100 起点，999 终点
	 * 功能：3** 重定向，401 未登录，403 操作重复，404 没有权限
	 * </p>
	 * @author 延晓磊
	 *
	 * @since 2017年7月7日
	 */
	public enum ResultEnum{
		/**
		 * 初始化(请求发送出去，但未收到响应，不知道是否接收和处理)
		 */
		INIT("100", LanguageUtil.match("未执行", "Initialization")),
		/**
		 * 成功状态(请求正常，根据结果数据data处理业务)
		 */
		SUCCESS("200", LanguageUtil.match("操作成功", "Operation successful")),

		/**
		 * 重定向状态（前端切换页面：data.str=?）
		 */
		REDIRECT("300", LanguageUtil.match("重定向页面", "Redirect")),
		/**
		 * 根窗口-重定向状态（前端切换页面：data.str=?）
		 */
		REDIRECT_TOP("320", LanguageUtil.match("重定向根页面", "Redirect top")),
		/**
		 * 转发状态（前端更换请求的接口：data.str=?）
		 */
		FORWARD("301", LanguageUtil.match("变更请求接口", "Change api")),
		/**
		 * 刷新（前端刷新页面）
		 */
		REFRESH("302", LanguageUtil.match("刷新页面", "Refresh")),
		/**
		 * 根窗口-刷新（前端刷新页面）
		 */
		REFRESH_TOP("322", LanguageUtil.match("刷新根页面", "Refresh top")),

		/**
		 * 业务错误状态（业务错误，参数错误，非法请求等，Warning）
		 */
		ERROR("400", LanguageUtil.match("操作失败", "Operation failed")),
		/**
		 * 登录认证失败状态（Token无效，需要重新登录）
		 */
		ERROR_LOGIN("401", LanguageUtil.match("登录失效", "Login failed")),
		/**
		 * 操作认证失败状态（Ticket无效，即重复提交或令牌过期）
		 */
		ERROR_TICKET("403", LanguageUtil.match("操作重复或超时", "Operation repeated or timeout")),
		/**
		 * 执行未授权操作状态（非法请求、访问过程中权限变更）
		 */
		ERROR_AUTH("404", LanguageUtil.match("没有权限", "No permission")),

		/**
		 * 服务器异常状态(后端出错，需要修改后端代码，Error)
		 */
		FAIL("500", LanguageUtil.match("服务异常", "Service error")),
		/**
		 * 服务端响应完成
		 */
		FINISH("999", LanguageUtil.match("响应完成", "Finished"));
		
		//状态码
		private final String status;
		
		//状态默认消息
		private final String msg;

		ResultEnum(String status, String msg) {
			this.status = status;
			this.msg = msg;
		}
		/**
		 * 
		 * 功能描述：状态码
		 */
		public String getStatus() {
			return status;
		}
		/**
		 * 
		 * 功能描述：状态默认消息
		 */
		public String getMsg() {
			return msg;
		}
	}
	
	/**
	 * 描述： 常用data键常量
	 *
	 * @author 延晓磊
	 *
	 * @since 2016年5月14日
	 */
	public static class DataKey {
		// 数字
		public static final String NUM = "num";
		// 字符串：文本值、HTML页面内容
		public static final String STR = "str";
		// 数组
		public static final String LIST = "list";
		// 布尔：0 == false; 1 = true
		public static final String BOOL = "bool";
		// 编号：请求成功，但返回自定义编号来调度
		public static final String CODE = "code";
	}
	
	// =============================== 常量Result ===================================//
	
	/**
	 * 初始化，请求发出但未响应(100)
	 */
	public static final Result INIT = new Result(ResultEnum.INIT.getStatus(), ResultEnum.INIT.getMsg(), null);
	/**
	 * 成功响应(200 - 成功)
	 */
	public static final Result SUCCESS = new Result(ResultEnum.SUCCESS.getStatus(), ResultEnum.SUCCESS.getMsg(), null);
	/**
	 * 空List(200)
	 */
	public static final Result SUCCESS_LIST = Result.successList(ListStr.EMPTY);
	/**
	 * 空Map(200)
	 */
	public static final Result SUCCESS_MAP = Result.success(MapSs.EMPTY);
	/**
	 * 空Pager(200)
	 */
	public static final Result SUCCESS_PAGER = Result.success(Pager.EMPTY_PAGER);
	/**
	 * 是 - Bool-1(200)
	 */
	public static final Result SUCCESS_YES = Result.success(DataKey.BOOL, IntegerConstant.N1);
	/**
	 * 否 - Bool-0(200)
	 */
	public static final Result SUCCESS_NO = Result.success(DataKey.BOOL, IntegerConstant.N0);
	/**
	 * 空String(200)
	 */
	public static final Result SUCCESS_STR = Result.successStr(StringConstant.EMPTY);
	
	/**
	 * 刷新页面 (302)
	 */
	public static final Result REFRESH = new Result(ResultEnum.REFRESH.getStatus(), ResultEnum.REFRESH.getMsg(), null );
	/**
	 * 刷新页面 - 根窗口 (322)
	 */
	public static final Result REFRESH_TOP = new Result(ResultEnum.REFRESH_TOP.getStatus(), ResultEnum.REFRESH_TOP.getMsg(), null );
	
	/**
	 * 业务错误响应(400 - 业务异常)
	 */
	public static final Result ERROR = new Result(ResultEnum.ERROR.getStatus(), ResultEnum.ERROR.getMsg(), null);
	/**
	 * 数据库录入重复数据(400)
	 */
	public static final Result ERROR_DATA_REPEAT = Result.error(LanguageUtil.match("数据录入重复，请修改后再试", "Data duplicate, please modify and try again"));
	/**
	 * 数据状态变更(400)
	 */
	public static final Result ERROR_DATA_CHANGE = Result.error(LanguageUtil.match("数据状态变更，请刷新后再试", "Data status has changed, please refresh and try again"));
	/**
	 * 重复操作(400)
	 */
	public static final Result ERROR_REPEAT = Result.error(LanguageUtil.match("操作重复", "Operation repeated"));
	/**
	 * 数据不存在(400)
	 */
	public static final Result ERROR_DATA_NULL = Result.error(LanguageUtil.match("数据为空", "Data does not exist"));
	/**
	 * 数据状态错误(400)
	 */
	public static final Result ERROR_DATA_STATUS = Result.error(LanguageUtil.match("数据状态错误", "Data status error"));
	/**
	 * 数据不一致(400)
	 */
	public static final Result ERROR_DATA_NOT_EQUALS = Result.error(LanguageUtil.match("数据不一致", "Data mismatch"));
	/**
	 * 参数为空(400)
	 */
	public static final Result ERROR_PARAM_NULL = Result.error(LanguageUtil.match("参数为空", "Parameter empty"));
	/**
	 * 参数太长(400)
	 */
	public static final Result ERROR_PARAM_LONG = Result.error(LanguageUtil.match("参数太长", "Parameter too long"));
	/**
	 * 参数错误(400)
	 */
	public static final Result ERROR_PARAM_ERROR = Result.error(LanguageUtil.match("参数错误", "Parameter error"));
	/**
	 * 参数校验错误(400)
	 */
	public static final Result ERROR_PARAM_ILLEGAL = Result.error(LanguageUtil.match("参数不符合规范", "Parameter illegal"));
	/**
	 * 参数类型错误(400)
	 */
	public static final Result ERROR_PARAM_TYPE = Result.error(LanguageUtil.match("参数类型错误", "Parameter type error"));
	/**
	 * 删除失败-级联(400)
	 */
	public static final Result ERROR_DELETE_CHILDREN = Result.error(LanguageUtil.match("删除失败，请先删除子节点", "Delete failed, please delete the child node first"));
	/**
	 * 删除失败-已使用(400)
	 */
	public static final Result ERROR_DELETE_USED = Result.error(LanguageUtil.match("删除失败，数据已被使用", "Delete failed, data has already been used"));
	/**
	 * 父节点不存在(400)
	 */
	public static final Result ERROR_PARENT_NULL = Result.error(LanguageUtil.match("父节点不存在", "Parent does not exist"));

	/**
	 * 服务繁忙(400 - 点击太快，操作频繁，操作重复，获取锁失败)
	 */
	public static final Result ERROR_BUSY = Result.error(LanguageUtil.match("服务繁忙，请稍侯再试", "Service is busy, please try again later"));
	/**
	 * 非法请求(400 - RequestRuntimeException)
	 */
	public static final Result ILLEGAL = Result.error(LanguageUtil.match("非法请求", "Request illegal"));
	/**
	 * 格式错误(400 - ParamRuntimeException)
	 */
	public static final Result TIME_FORMAT_ERROR = Result.error(LanguageUtil.match("时间格式错误", "Time format error"));

	/**
	 * Token无效(401 - 登录)
	 */
	public static final Result ERROR_LOGIN = new Result(ResultEnum.ERROR_LOGIN.getStatus(), ResultEnum.ERROR_LOGIN.getMsg(), null);

	/**
	 * Ticket无效(403 - 操作票据)
	 */
	public static final Result ERROR_TICKET = new Result(ResultEnum.ERROR_TICKET.getStatus(), ResultEnum.ERROR_TICKET.getMsg(), null);
	/**
	 * 执行未授权操作(404 - AuthRuntimeException)
	 */
	public static final Result ERROR_AUTH = new Result(ResultEnum.ERROR_AUTH.getStatus(), ResultEnum.ERROR_AUTH.getMsg(), null);

	/**
	 * 异步响应(500 - 服务异常)
	 */
	public static final Result FAIL = new Result(ResultEnum.FAIL.getStatus(), ResultEnum.FAIL.getMsg(), null);
	/**
	 * 完成响应(999 - 完成)
	 */
	public static final Result FINISH = new Result(ResultEnum.FINISH.getStatus(), ResultEnum.FINISH.getMsg(), null);
	

	// =============================== 常量Result-JSON串 ===================================//
	
	/**
	 * 成功响应(200 - 成功)_JSON
	 */
	public static final String SUCCESS_JSON = JsonUtil.toStr(SUCCESS);
	/**
	 * 空List(200)
	 */
	public static final String SUCCESS_LIST_JSON = JsonUtil.toStr(SUCCESS_LIST);
	/**
	 * 空Map(200)
	 */
	public static final String SUCCESS_MAP_JSON = JsonUtil.toStr(SUCCESS_MAP);
	/**
	 * 是 - Bool-1(200)_JSON
	 */
	public static final String SUCCESS_YES_JSON = JsonUtil.toStr(SUCCESS_YES);
	/**
	 * 否 - Bool-0(200)_JSON
	 */
	public static final String SUCCESS_NO_JSON = JsonUtil.toStr(SUCCESS_NO);

	/**
	 * 业务错误响应(400 - 业务异常)_JSON
	 */
	public static final String ERROR_JSON = JsonUtil.toStr(ERROR);
	/**
	 * 数据不存在(400)_JSON
	 */
	public static final String ERROR_DATA_NULL_JSON = JsonUtil.toStr(ERROR_DATA_NULL);
	/**
	 * 参数为空(400)_JSON
	 */
	public static final String ERROR_PARAM_NULL_JSON = JsonUtil.toStr(ERROR_PARAM_NULL);
	/**
	 * 参数错误(400)_JSON
	 */
	public static final String ERROR_PARAM_ERROR_JSON = JsonUtil.toStr(ERROR_PARAM_ERROR);
	/**
	 * 参数校验错误(400)_JSON
	 */
	public static final String ERROR_PARAM_ILLEGAL_JSON = JsonUtil.toStr(ERROR_PARAM_ILLEGAL);
	/**
	 * 非法请求(400 - RequestRuntimeException)_JSON
	 */
	public static final String ILLEGAL_JSON = JsonUtil.toStr(ILLEGAL);

	/**
	 * Token无效(401 - 登录)_JSON
	 */
	public static final String ERROR_LOGIN_JSON = JsonUtil.toStr(ERROR_LOGIN);
	/**
	 * Ticket无效(403 - 操作票据)_JSON
	 */
	public static final String ERROR_TICKET_JSON = JsonUtil.toStr(ERROR_TICKET);
	/**
	 * 执行未授权操作(404 - AuthRuntimeException)_JSON
	 */
	public static final String ERROR_AUTH_JSON = JsonUtil.toStr(ERROR_AUTH);

	/**
	 * 异常响应(500 - 服务异常)_JSON
	 */
	public static final String FAIL_JSON = JsonUtil.toStr(FAIL);
	
	/**
	 * 完成响应(999 - 完成)_JSON
	 */
	public static final String FINISH_JSON = JsonUtil.toStr(FINISH);
	
	
	// =============================== 错误Result转发的页面 ===================================//

	/**
	 * "错误码" 和 "错误页面路径" 的映射
	 * 
	 * 作用：发生异常时，根据错误码，转发到不同的错误页面
	 */
	public static final Map<String,String> ERROR_PAGE = new HashMap<String,String>(){
		private static final long serialVersionUID = 1L;
	{
		put(ResultEnum.ERROR.getStatus(), "comm/error_400");
		put(ResultEnum.ERROR_LOGIN.getStatus(), "comm/error_401");
		put(ResultEnum.ERROR_TICKET.getStatus(), "comm/error_403");
		put(ResultEnum.ERROR_AUTH.getStatus(), "comm/error_404");
		put(ResultEnum.FAIL.getStatus(), "comm/error_500");
	}};
 
	// =============================== 创建Result ===================================//
	
	/**
	 * 构造响应结果
	 * 
	 */
	public Result() {
		super();
	}

	/**
	 * 构造响应结果
	 * 
	 * @param status
	 * @param msg
	 * @param data
	 */
	public Result(String status, String msg, Object data) {
		this.status = status;
		this.msg = msg;
		this.data = data;
	}

	/**
	 * 自定义响应
	 * 
	 * @param status
	 * @param msg
	 * @param data
	 * @return {status:status,msg:msg,data:data}
	 */
	public static Result build(String status, String msg, Object data) {
		return new Result(status, msg, data);
	}
	
	/**
	 * 初始化
	 *
	 * @return {status:100,msg:"INIT",data:null}
	 */
	public static Result init() {
		return Result.INIT;
	}

	/**
	 * 功能描述：重定向响应 - 更换页面
	 *	
	 * @param url	重定向页面的URL或标记
	 * @return {status:300,msg:"REDIRECT",data:{str:xxx}}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年5月14日
	 */
	public static Result redirect(String url){
		JSONObject anyMap = new JSONObject(1);
		anyMap.put(DataKey.STR, url);
		return new Result(ResultEnum.REDIRECT.getStatus(), ResultEnum.REDIRECT.getMsg(), anyMap );
	}
	
	/**
	 * 功能描述：根窗口-重定向响应 - 更换页面
	 *	
	 * @param url	重定向页面的URL或标记
	 * @return {status:320,msg:"REDIRECT",data:{str:xxx}}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年5月14日
	 */
	public static Result redirectTop(String url){
		JSONObject anyMap = new JSONObject(1);
		anyMap.put(DataKey.STR, url);
		return new Result(ResultEnum.REDIRECT_TOP.getStatus(), ResultEnum.REDIRECT_TOP.getMsg(), anyMap );
	}
	
	/**
	 * 功能描述：转发响应 - 更换请求地址
	 *	
	 * @param url	转发的请求的URL或标记
	 * @return {status:301,msg:"FORWARD",data:{str:xxx}}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年5月14日
	 */
	public static Result forward(String url){
		JSONObject anyMap = new JSONObject(1);
		anyMap.put(DataKey.STR, url);
		return new Result(ResultEnum.FORWARD.getStatus(), ResultEnum.FORWARD.getMsg(), anyMap );
	}
	
	/**
	 * 功能描述：刷新页面
	 *	
	 * @return {status:302}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年5月14日
	 */
	public static Result refresh(){
		return Result.REFRESH;
	}
	
	/**
	 * 功能描述：根窗口-刷新页面
	 *	
	 * @return {status:322}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年5月14日
	 */
	public static Result refreshTop(){
		return Result.REFRESH_TOP;
	}
	
	/**
	 * 业务错误响应
	 * 
	 * @return {status:400,msg:"ERROR",data:null}
	 */
	public static Result error() {
		return Result.ERROR;
	}

	/**
	 * 业务错误响应
	 * 
	 * @param msg 业务处理错误信息
	 * @return {status:400,msg:msg,data:null}
	 */
	public static Result error(String msg) {
		return new Result(ResultEnum.ERROR.getStatus(), msg, null);
	}
 
	/**
	 * 业务错误响应
	 * <pre>
	 * 场景：前端需要根据出错的原因进行个性化处理。
	 * 示例：例如金额不足时，前端不再简单的弹错误框，而是打开充值页面并提示"商品价格200，可用余额30，请先充值"
	 * 参数：{status: 400, msg: 'BALANCE', data: {price:200, avail:30} }
	 * </pre>
	 * @param msg 	自定义错误标记（前后端约定）
	 * @param data  业务数据
	 * @return {status:400,msg:msg,data:data}
	 */
	public static Result error(String msg, Object data) {
		return new Result(ResultEnum.ERROR.getStatus(), msg, data);
	}
	
	/**
	 * 服务异常响应
	 * 
	 * @return {status:500,msg:"FAIL",data:null}
	 */
	public static Result fail() {
		return Result.FAIL;
	}

	/**
	 * 服务器异常响应
	 * 
	 * @param msg 异常终止信息
	 * @return {status:500,msg:msg,data:null}
	 */
	public static Result fail(String msg) {
		return new Result(ResultEnum.FAIL.getStatus(), msg, null);
	}

	/**
	 * 登录校验失败响应
	 * 
	 * @return {status:401,msg:"ERROR_LOGIN",data:null}
	 */
	public static Result errorLogin() {
		return Result.ERROR_LOGIN;
	}

	/**
	 * Ticket无效响应
	 * 
	 * @return {status:403,ERROR_TICKET,data:null}
	 */
	public static Result ticket() {
		return Result.ERROR_TICKET;
	}
	
	/**
	 * 访问未授权资源错误
	 * 
	 * @return {status:404,msg:"ERROR_AUTH",data:null}
	 */
	public static Result auth() {
		return Result.ERROR_AUTH;
	}

	/**
	 * 完成响应
	 * 
	 * @return {status:999,msg:"FINISH",data:null}
	 */
	public static Result finish() {
		return Result.FINISH;
	}

	/**
	 * 警告响应
	 * 
	 * @param msg	错误消息：前端判断code非空，表示为警告响应（伪200），应弹窗msg并根据code调度
	 * @param code	错误编码，默认1：前端判断非空时根据约定的code调度
	 * 
	 * @return {status:200, msg: msg, data: {code:code} }
	 * 
	 * @author 延晓磊
	 *
	 * @since 2020年3月20日
	 */
	public static Result warn(String msg, String code) {
		return new Result(ResultEnum.SUCCESS.getStatus(), msg, MapSo.getInstance(DataKey.CODE, StringUtil.toDefault(code, Common.YES)));
	}
	
	/**
	 * 警告响应
	 * 
	 * @param msg	错误消息：前端判断code非空，表示为警告响应（伪200），应弹窗msg并根据约定调度
	 * @param data	错误数据：前端根据错误数据进行调度
	 * 
	 * @return {status:200, msg: msg, data: {code:1, data...} }
	 * 
	 * @author 延晓磊
	 *
	 * @since 2020年3月20日
	 */
	public static Result warn(String msg, Map<String,Object> data) {
		return warn(msg, null, data);
	}
	
	/**
	 * 警告响应
	 * 
	 * @param msg	错误消息：前端判断code非空，表示为警告响应（伪200），应弹窗msg并根据code调度
	 * @param code	错误编码：前端判断非空时根据约定的code调度
	 * @param data	错误数据：前端根据错误数据进行调度
	 * 
	 * @return {status:200, msg: msg, data: {code:code, data...} }
	 * 
	 * @author 延晓磊
	 *
	 * @since 2020年3月20日
	 */
	public static Result warn(String msg, String code, Map<String,Object> data) {
		if (data == null) {
			return warn(msg, code);
		}else {
			data.put(DataKey.CODE, StringUtil.toDefault(code, Common.YES));
			return new Result(ResultEnum.SUCCESS.getStatus(), msg, data);
		}
	}
	
	/**
	 * 成功响应
	 * 
	 * @return {status:200,msg:"SUCCESS",data:null}
	 */
	public static Result success() {
		return Result.SUCCESS;
	}

	/**
	 * 成功响应(多键值对类型，Object、 Map)
	 * 
	 * @param data
	 *            键值对类型结果
	 * @return {status:200,msg:"SUCCESS",data:data}
	 */
	public static Result success(Object data) {
		return new Result(ResultEnum.SUCCESS.getStatus(), ResultEnum.SUCCESS.getMsg(), data);
	}

	/**
	 * 
	 * 成功响应(键值对类型)
	 *
	 * @param key
	 *            data的键
	 * @param value
	 *            data的值
	 * @return {status:200,msg:"SUCCESS",data:{key,value}}
	 */
	public static Result success(String key, Object value) {
		JSONObject anyMap = new JSONObject(1);
		anyMap.put(key, value);
		return new Result(ResultEnum.SUCCESS.getStatus(), ResultEnum.SUCCESS.getMsg(), anyMap);
	}

	/**
	 * 成功响应(布尔类型)
	 * 
	 * @param bool  true:1,false:0
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:1/0}}
	 */
	public static Result successBool(boolean bool) {
		if (bool) {
			return Result.SUCCESS_YES;
		}else {
			return Result.SUCCESS_NO;
		}
	}
	
	/**
	 * 成功响应(布尔类型)
	 * 
	 * @param bool  true:1,false:0
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:1/0}}
	 */
	public static Result successBool(Integer bool) {
		return successBool(!IntegerConstant.N0.equals(bool));
	}
	
	/**
	 * 成功响应(布尔类型)
	 * 
	 * @param bool  true:1,false:0
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:1/0}}
	 */
	public static Result successBool(Long bool) {
		return successBool(!LongConstant.N0.equals(bool));
	}
	
	/**
	 * 成功响应(布尔类型)
	 * 
	 * @param bool  true:1,false:0
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:1/0}}
	 */
	public static Result successBool(String bool) {
		return successBool(!StringConstant.N0.equals(bool));
	}
	
	/**
	 * 成功响应(布尔类型， 1是)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:1}}
	 */
	public static Result successBoolYes() {
		return Result.SUCCESS_YES;
	}

	/**
	 * 成功响应(布尔类型， 0否)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{bool:0}}
	 */
	public static Result successBoolNo() {
		return Result.SUCCESS_NO;
	}

	/**
	 * 成功响应(数组集合类型，Array)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{list:[]}}
	 */
	public static <T>Result successList(T[] list) {
		return success(DataKey.LIST, list);
	}

	/**
	 * 成功响应(数组集合类型，List、Set)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{list:[]}}
	 */
	public static Result successList(Iterable<?> list) {
		return success(DataKey.LIST, list);
	}

	/**
	 * 成功响应(Number类型)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{num:''}}
	 */
	public static Result successNum(Number num) {
		return success(DataKey.NUM, num);
	}

	/**
	 * 成功响应(Number类型)
	 *
	 * 注意：数值过大时，前端可能丢失精度，所以大数通常使用String类型
	 *
	 * @return {status:200,msg:"SUCCESS",data:{num:''}}
	 */
	public static Result successNum(String num) {
		return success(DataKey.NUM, num);
	}

	/**
	 * 成功响应(String类型)
	 * 
	 * @return {status:200,msg:"SUCCESS",data:{str:''}}
	 */
	public static Result successStr(String str) {
		return success(DataKey.STR, str);
	}

	// =============================== 解析REST-Result ===================================//
	
	/**
	 * 
	 * 功能描述：判断是否响应成功
	 *
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public boolean isSuccess() {
		return isSuccess(this);
	}
	
	/**
	 * 
	 * 功能描述：判断是否响应错误（前缀4）
	 *
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public boolean isError() {
		return isError(this);
	}
	
	/**
	 * 
	 * 功能描述：判断是否响应异常（前缀5）
	 *
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public boolean isFail() {
		return isFail(this);
	}
	 
	/**
	 * REST请求的结果校验
	 * 
	 * @return "成功/重定向"返回result，"失败/异常"抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Result rest(){
		return rest(this);
	}

	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回result.data，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T>T rest(Class<T> clazz){
		return rest(this,clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回JSONObject(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public JSONObject restJson(){
		return restJson(this);
	}

	/**
	 * REST请求的结果校验
	 *
	 * @return 成功返回Map<K,V>(result.data)，失败抛异常
	 *
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <K,V>Map<K, V> restMap(Class<K> keyClass, Class<V> valueClass){
		return restMap(this,keyClass,valueClass);
	}

	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回Map<String,T>(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T>Map<String, T> restMap(Class<T> clazz){
		return restMap(this,clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回Map<String,String>(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Map<String, String> restMap(){
		return restMap(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回result.bool，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public boolean restBool(){
		return restBool(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回list，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T>List<T> restList(Class<T> clazz){
		return restList(this,clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回str，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public String restStr(){
		return restStr(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Number restNum(){
		return restNum(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Long restLong(){
		return restLong(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Integer restInt(){
		return restInt(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Double restDouble(){
		return restDouble(this);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Float restFloat(){
		return restFloat(this);
	}

	// =============================== 静态解析REST-Result ===================================//
	
	/**
	 * 功能描述：判断是否响应成功（200）
	 *
	 * @param result
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static boolean isSuccess(Result result) {
		return  result != null && ResultEnum.SUCCESS.getStatus().equals(result.getStatus());
	}

	/**
	 * 功能描述：判断是否响应重定向/刷新（前缀3）
	 *
	 * @param result
	 * @return
	 *
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static boolean isRedirect(Result result) {
		return result != null && result.getStatus().startsWith("3");
	}
	
	/**
	 * 功能描述：判断是否响应错误（前缀4）
	 *
	 * @param result
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static boolean isError(Result result) {
		return result != null && result.getStatus().startsWith("4");
	}
	
	/**
	 * 功能描述：判断是否响应异常（前缀5）
	 *
	 * @param result
	 * @return
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static boolean isFail(Result result) {
		return result != null && result.getStatus().startsWith("5");
	}
	 
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return "成功/重定向"返回result，"失败/异常"抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Result rest(Result result){
		//是否请求成功、重写向
		if (Result.isSuccess(result) || Result.isRedirect(result)) {
			return result;
		}
		//错误消息(如果发生警告消息时不抛异常，可以在调用Result.rest时捕捉BizRuntimeException)
		if (Result.isError(result)) {
			LOG.warn(REST_ERROR_LOG, result);
			throw new BizRuntimeException(result.getMsg());
		}
		//服务异常（其它REST调用不可能出现其它异常，有也是代码问题，须在开发时解决）
		LOG.error(REST_ERROR_LOG, result);
		throw RestRuntimeException.COMMON;
	}

	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回result.data，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static <T>T rest(Result result,Class<T> clazz){
		return getObjData(rest(result),clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * 
	 * @return 成功返回JSONObject(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static JSONObject restJson(Result result){
		return getJsonData(rest(result));
	}

	/**
	 * REST请求的结果校验
	 *
	 * @param result
	 *
	 * @return 成功返回Map<K,V>(result.data)，失败抛异常
	 *
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static <K,V>Map<K,V> restMap(Result result, Class<K> keyClass, Class<V> valueClass){
		return getMapData(rest(result),keyClass,valueClass);
	}

	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * 
	 * @return 成功返回Map<String,T>(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static <T>Map<String, T> restMap(Result result, Class<T> clazz){
		return getMapData(rest(result),clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * 
	 * @return 成功返回Map<String,String>(result.data)，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Map<String, String> restMap(Result result){
		return getMapData(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回result.bool，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static boolean restBool(Result result){
		return getBoolData(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回list，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static <T>List<T> restList(Result result,Class<T> clazz){
		return getListData(rest(result),clazz);
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回str，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static String restStr(Result result){
		return getStrData(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Number restNum(Result result){
		return getNumData(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Long restLong(Result result){
		return getNumDataLong(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Integer restInt(Result result){
		return getNumDataInt(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Double restDouble(Result result){
		return getNumDataDouble(rest(result));
	}
	
	/**
	 * REST请求的结果校验
	 * 
	 * @param result
	 * @return 成功返回num，失败抛异常
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月30日
	 */
	public static Float restFloat(Result result){
		return getNumDataFloat(rest(result));
	}
	
	// ===============================获取Result.data ===================================//
	
	/**
	 * 
	 * 功能描述：获取successBool型的布尔值
	 *
	 * @return true/false 如果data为空将抛异常
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public boolean getBool() {
		return getBoolData(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successBool型的布尔值
	 *
	 * @param result
	 * @return true/false 如果data为空将抛异常
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static boolean getBoolData(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return IntegerConstant.N1.equals(jsonData.getInteger(DataKey.BOOL));
		}
		return false;
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @return Number
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public Number getNum() {
		return getNumData(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @param result
	 * @return Number
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static Number getNumData(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return (Number)jsonData.get(DataKey.NUM);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @return Long
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public Long getLong() {
		return getNumDataLong(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @param result
	 * @return Long
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static Long getNumDataLong(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return jsonData.getLong(DataKey.NUM);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @return Integer
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public Integer getInt() {
		return getNumDataInt(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @param result
	 * @return Integer
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static Integer getNumDataInt(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return jsonData.getInteger(DataKey.NUM);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @return Double
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public Double getDouble() {
		return getNumDataDouble(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @param result
	 * @return Double
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static Double getNumDataDouble(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return jsonData.getDouble(DataKey.NUM);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @return Float
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public Float getFloat() {
		return getNumDataFloat(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successNum型的data值
	 *
	 * @param result
	 * @return Float
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static Float getNumDataFloat(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return jsonData.getFloat(DataKey.NUM);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successStr型的data值
	 *
	 * @return String
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	@JSONField(serialize=false,deserialize=false)
	public String getStr() {
		return getStrData(this);
	}
	
	/**
	 * 
	 * 功能描述：获取successStr型的data值
	 *
	 * @param result
	 * @return String
	 * 
	 * @author yxl
	 *
	 * @since 2016-9-20
	 */
	public static String getStrData(Result result) {
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			return jsonData.getString(DataKey.STR);
		}
		return null;
	}
	
	/**
	 * 
	 * 功能描述：获取successList的Data
	 *
	 * @param clazz
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T> List<T> getList(Class<T> clazz ){
		return getListData(this, clazz);
	}
	
	/**
	 * 
	 * 功能描述：获取successList的Data
	 *
	 * @param result
	 * @param clazz
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static <T> List<T> getListData(Result result,Class<T> clazz ){
		JSONObject jsonData = Result.getJsonData(result);
		if (jsonData != null) {
			JSONArray jsonArray = jsonData.getJSONArray(DataKey.LIST);
			if (jsonArray != null) {
				return jsonArray.toJavaList(clazz);
			}
		}
		return null;
	}
	
	/**
	 * 功能描述：获取Map<String,String>类型的data
	 *
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	@JSONField(serialize=false,deserialize=false)
	public Map<String,String> getMap(){
		return getMapData(this);
	}
	
	/**
	 * 
	 * 功能描述：获取Map<String,String>类型的data
	 *
	 * @param result
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static Map<String,String> getMapData(Result result){
		// 获取map
		JSONObject jsonData = getJsonData(result);
		if (jsonData == null) {
			return null;
		}else {
			// 转换Map
			Map<String,String> map = new HashMap<>();
			for (String key : jsonData.keySet()) {
				 map.put(key, jsonData.getString(key));
			}
			return map;
		}
	}
	
	/**
	 * 功能描述：获取Map<String,T>类型的data
	 *
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T>Map<String,T> getMap(Class<T> clazz){
		return getMapData(this,clazz);
	}
	
	/**
	 * 功能描述：获取Map<String,T>类型的data
	 *
	 * @param result
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static <T>Map<String,T> getMapData(Result result, Class<T> clazz){
		// 获取map
		JSONObject jsonData = getJsonData(result);
		if (jsonData == null) {
			return null;
		}else {
			// 转换Map
			Map<String,T> map = new HashMap<>();
			for (String key : jsonData.keySet()) {
				map.put(key, jsonData.getObject(key, clazz));
			}
			return map;
		}
	}

	/**
	 * 功能描述：获取Map<String,T>类型的data
	 *
	 * @param result
	 * @return
	 *
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static <K,V>Map<K,V> getMapData(Result result,  Class<K> keyClass,  Class<V> valueClass){
		// 获取map
		JSONObject jsonData = getJsonData(result);
		if (jsonData == null) {
			return null;
		}else {
			// 转换Map
			Map<K,V> map = new HashMap<>();
			for (String key : jsonData.keySet()) {
				map.put(ObjectUtil.cast(key, keyClass), jsonData.getObject(key, valueClass));
			}
			return map;
		}
	}

	/**
	 * 获取JSONObject（Map<String,Object>）类型的data
	 * 
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年11月24日
	 */
	@JSONField(serialize=false,deserialize=false)
	public JSONObject getJson(){
		return getJsonData(this);
	}
	
	/**
	 * 获取JSONObject（Map<String,Object>）类型的data
	 * 
	 * @param result
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年11月24日
	 */
	public static JSONObject getJsonData(Result result){
		if (result == null) {
			return null;
		}
		Object rdata = result.getData();
		if(rdata == null) return null;
		//默认会转换为LinkedHashMap，需要先转换成String，再转成JSON
		return JsonUtil.parseObject(JsonUtil.toStr(rdata));
	}
	
	/**
	 * 获取JSONObject（Map<String,Object>）类型的data
	 * 
	 * @param result
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年11月24日
	 */
	public static JSONObject getJsonData(String result){
		return getJsonData(Result.parseJson(result));
	}
	
	/**
	 * 
	 * 功能描述：获取Object类型的Data
	 *
	 * @param clazz
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	@JSONField(serialize=false,deserialize=false)
	public <T> T getObj(Class<T> clazz){
		return getObjData(this, clazz);
	}
	
	/**
	 * 
	 * 功能描述：获取Object类型的Data
	 *
	 * @param result
	 * @param clazz
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static <T> T getObjData(Result result,Class<T> clazz){
		if (result == null) {
			return null;
		}
		Object rdata = result.getData();
		if(rdata == null) return null;
		return JsonUtil.parse(JsonUtil.toStr(rdata), clazz);
	}
	
	/**
	 * 
	 * 功能描述：获取Object类型的Data
	 *
	 * @param json
	 * @param clazz
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static <T> T getObjData(String json,Class<T> clazz){
		return getObjData(Result.parseJson(json), clazz);
	}
	
	// =============================== 序列化Result ===================================//
 
	/**
	 * 结果转换：转换Result为JSON串
	 * 
	 * @param result
	 * @return JSON串
	 */
	public static String toJson(Result result) {
		return JsonUtil.toStr(result);
	}
	/**
	 * 结果转换：转换Result为JSON串
	 * 
	 * @return JSON串
	 */
	public String toJson() {
		return toJson(this);
	}
	
	/**
	 * 结果转换：转换Result为JSONP串
	 * 
	 * @param result
	 * @return JSONP串
	 */
	public static String toJsonp(Result result, String callback) {
		return callback.trim().concat(JSONP_LEFT).concat(toJson(result)).concat(JSONP_RIGHT);
	}

	/**
	 * 结果转换：转换Result为JSONP串
	 * 
	 * @param callback
	 * @return JSONP串
	 */
	public String toJsonp(String callback) {
		return toJsonp(this,callback);
	}

	/**
	 * 根据aop-method的返回值类型进行转换（用于AOP的@Aound主动返回Result结果）
	 *
	 * @param method
	 * @return Result(子类保留status,msg,data)/Result.toJson(String)/Exception(其它类型)
	 */
	public Object toAop(Method method){
		// 返回类型
		Class<?> returnType = method.getReturnType();
		if (Result.class.equals(returnType)) {
			// Result
			return this;
		}else if (String.class.equals(returnType)) {
			// Result.toJson
			return this.toJson();
		}else if (ReflectClassUtil.isSupper(Result.class, returnType)) {
			// Result Child
			return ReflectClassUtil.instance(returnType, MapSo.getInstance("status", this.status, "msg", this.msg, "data", this.data));
		}else{
			// 其它类型：如果要使用其它类型，建议不被AOP处理并返回Result，否则直接抛异常（在Controller的AOP中通过异常拦截器，用response直接输出错误）
			if (this.getStatus().equals(ERROR_LOGIN.getStatus())) {
				// 未登录
				throw TokenRuntimeException.NO_LOGIN;
			}else if (this.getStatus().equals(ERROR_AUTH.getStatus())) {
				// 没有权限
				throw new AuthRuntimeException(this.getMsg());
			}else if (this.getStatus().equals(FAIL.getStatus())) {
				// 服务异常
				throw new BizErrorRuntimeException(this.getMsg());
			}else if (this.getStatus().equals(SUCCESS.getStatus())) {
				// 成功
				if (void.class.equals(returnType)) {
					return null;
				}else{
					// 其它类型的成功，不应该调用toApp，否则按异常处理
					LOG.error("返回类型必须是Result/String，不能是" + returnType.getName());
					throw new ErrorRuntimeException("响应类型错误");
				}
			}else{
				// 其它错误
				throw new BizRuntimeException(this.getMsg());
			}
		}
	}

	// =============================== 转换Result ===================================//
	
	/**
	 * 
	 * 功能描述：将JSON串转换为Result
	 *
	 * @param json
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年7月6日
	 */
	public static Result parseJson(String json){
		return JsonUtil.parse(json, Result.class);
	}
 
	/**
	 * 排序参数
	 * 
	 * @param sort	排序参数 -- 排序字段:排序方式(0升，1降)，例 "id:1,age:0"
	 * @return	
	 * 
	 * @author 延晓磊
	 *
	 * @since 2017年12月12日
	 */
	public static String[] getSortParam(String sort){
		return StringUtil.splitStrict(sort);
	}
	
	/**
	 * 返回Success Result的Data
	 * 
	 * 1、本地调用
	 * 2、data的类型为JsonObject，即Result通过successList,successStr等方法创建
	 * 
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年6月25日
	 */
	public JSONObject parseData() {
		if (this.getData() == null) {
			return null;
		}
		return (JSONObject)(this.getData());
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}
	
	@Override
	public String toString() {
		return "Result [status=" + status + ", msg=" + msg + ", data=" + data + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((data == null) ? 0 : data.hashCode());
		result = prime * result + ((msg == null) ? 0 : msg.hashCode());
		result = prime * result + ((status == null) ? 0 : status.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Result other = (Result) obj;
		if (data == null) {
			if (other.data != null)
				return false;
		} else if (!data.equals(other.data))
			return false;
		if (msg == null) {
			if (other.msg != null)
				return false;
		} else if (!msg.equals(other.msg))
			return false;
		if (status == null) {
			return other.status == null;
		} else return status.equals(other.status);
	}

}
